/* motion.c, motion vector decoding                                         */



/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */



/*

 * Disclaimer of Warranty

 *

 * These software programs are available to the user without any license fee or

 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims

 * any and all warranties, whether express, implied, or statuary, including any

 * implied warranties or merchantability or of fitness for a particular

 * purpose.  In no event shall the copyright-holder be liable for any

 * incidental, punitive, or consequential damages of any kind whatsoever

 * arising from the use of these programs.

 *

 * This disclaimer of warranty extends to the user of these programs and user's

 * customers, employees, agents, transferees, successors, and assigns.

 *

 * The MPEG Software Simulation Group does not represent or warrant that the

 * programs furnished hereunder are free of infringement of any third-party

 * patents.

 *

 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,

 * are subject to royalty fees to patent holders.  Many of these patents are

 * general enough such that they are unavoidable regardless of implementation

 * design.

 *

 */



#include <stdio.h>



#include "config.h"

#include "global.h"



/* private prototypes */

static void decode_motion_vector _ANSI_ARGS_((int *pred, int r_size, int motion_code,

  int motion_residualesidual, int full_pel_vector));



/* ISO/IEC 13818-2 sections 6.2.5.2, 6.3.17.2, and 7.6.3: Motion vectors */

void motion_vectors(PMV,dmvector,

  motion_vertical_field_select,s,motion_vector_count,mv_format,h_r_size,v_r_size,dmv,mvscale)

int PMV[2][2][2];

int dmvector[2];

int motion_vertical_field_select[2][2];

int s, motion_vector_count, mv_format, h_r_size, v_r_size, dmv, mvscale;

{

  if (motion_vector_count==1)

  {

    if (mv_format==MV_FIELD && !dmv)

    {

      motion_vertical_field_select[1][s] = motion_vertical_field_select[0][s] = Get_Bits(1);

#ifdef TRACE

      if (Trace_Flag)

      {

        printf("motion_vertical_field_select[][%d] (%d): %d\n",s,

          motion_vertical_field_select[0][s],motion_vertical_field_select[0][s]);

      }

#endif /* TRACE */

    }



    motion_vector(PMV[0][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);



    /* update other motion vector predictors */

    PMV[1][s][0] = PMV[0][s][0];

    PMV[1][s][1] = PMV[0][s][1];

  }

  else

  {

    motion_vertical_field_select[0][s] = Get_Bits(1);

#ifdef TRACE

    if (Trace_Flag)

    {

      printf("motion_vertical_field_select[0][%d] (%d): %d\n",s,

        motion_vertical_field_select[0][s],motion_vertical_field_select[0][s]);

    }

#endif /* TRACE */

    motion_vector(PMV[0][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);



    motion_vertical_field_select[1][s] = Get_Bits(1);

#ifdef TRACE

    if (Trace_Flag)

    {

      printf("motion_vertical_field_select[1][%d] (%d): %d\n",s,

        motion_vertical_field_select[1][s],motion_vertical_field_select[1][s]);

    }

#endif /* TRACE */

    motion_vector(PMV[1][s],dmvector,h_r_size,v_r_size,dmv,mvscale,0);

  }

}



/* get and decode motion vector and differential motion vector 

   for one prediction */

void motion_vector(PMV,dmvector,

  h_r_size,v_r_size,dmv,mvscale,full_pel_vector)

int *PMV;

int *dmvector;

int h_r_size;

int v_r_size;

int dmv; /* MPEG-2 only: get differential motion vectors */

int mvscale; /* MPEG-2 only: field vector in frame pic */

int full_pel_vector; /* MPEG-1 only */

{

  int motion_code, motion_residual;



  /* horizontal component */

  /* ISO/IEC 13818-2 Table B-10 */

  motion_code = Get_motion_code();



  motion_residual = (h_r_size!=0 && motion_code!=0) ? Get_Bits(h_r_size) : 0;



#ifdef TRACE

  if (Trace_Flag)

  {

    if (h_r_size!=0 && motion_code!=0)

    {

      printf("motion_residual (");

      Print_Bits(motion_residual,h_r_size,h_r_size);

      printf("): %d\n",motion_residual);

    }

  }

#endif /* TRACE */





  decode_motion_vector(&PMV[0],h_r_size,motion_code,motion_residual,full_pel_vector);



  if (dmv)

    dmvector[0] = Get_dmvector();





  /* vertical component */

  motion_code     = Get_motion_code();

  motion_residual = (v_r_size!=0 && motion_code!=0) ? Get_Bits(v_r_size) : 0;



#ifdef TRACE

  if (Trace_Flag)

  {

    if (v_r_size!=0 && motion_code!=0)

    {

      printf("motion_residual (");

      Print_Bits(motion_residual,v_r_size,v_r_size);

      printf("): %d\n",motion_residual);

    }

  }

#endif /* TRACE */



  if (mvscale)

    PMV[1] >>= 1; /* DIV 2 */



  decode_motion_vector(&PMV[1],v_r_size,motion_code,motion_residual,full_pel_vector);



  if (mvscale)

    PMV[1] <<= 1;



  if (dmv)

    dmvector[1] = Get_dmvector();



#ifdef TRACE

  if (Trace_Flag)

    printf("PMV = %d,%d\n",PMV[0],PMV[1]);

#endif /* TRACE */

}



/* calculate motion vector component */

/* ISO/IEC 13818-2 section 7.6.3.1: Decoding the motion vectors */

/* Note: the arithmetic here is more elegant than that which is shown 

   in 7.6.3.1.  The end results (PMV[][][]) should, however, be the same.  */



static void decode_motion_vector(pred,r_size,motion_code,motion_residual,full_pel_vector)

int *pred;

int r_size, motion_code, motion_residual;

int full_pel_vector; /* MPEG-1 (ISO/IEC 11172-1) support */

{

  int lim, vec;



  lim = 16<<r_size;

  vec = full_pel_vector ? (*pred >> 1) : (*pred);



  if (motion_code>0)

  {

    vec+= ((motion_code-1)<<r_size) + motion_residual + 1;

    if (vec>=lim)

      vec-= lim + lim;

  }

  else if (motion_code<0)

  {

    vec-= ((-motion_code-1)<<r_size) + motion_residual + 1;

    if (vec<-lim)

      vec+= lim + lim;

  }

  *pred = full_pel_vector ? (vec<<1) : vec;

}





/* ISO/IEC 13818-2 section 7.6.3.6: Dual prime additional arithmetic */

void Dual_Prime_Arithmetic(DMV,dmvector,mvx,mvy)

int DMV[][2];

int *dmvector; /* differential motion vector */

int mvx, mvy;  /* decoded mv components (always in field format) */

{

  if (picture_structure==FRAME_PICTURE)

  {

    if (top_field_first)

    {

      /* vector for prediction of top field from bottom field */

      DMV[0][0] = ((mvx  +(mvx>0))>>1) + dmvector[0];

      DMV[0][1] = ((mvy  +(mvy>0))>>1) + dmvector[1] - 1;



      /* vector for prediction of bottom field from top field */

      DMV[1][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];

      DMV[1][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] + 1;

    }

    else

    {

      /* vector for prediction of top field from bottom field */

      DMV[0][0] = ((3*mvx+(mvx>0))>>1) + dmvector[0];

      DMV[0][1] = ((3*mvy+(mvy>0))>>1) + dmvector[1] - 1;



      /* vector for prediction of bottom field from top field */

      DMV[1][0] = ((mvx  +(mvx>0))>>1) + dmvector[0];

      DMV[1][1] = ((mvy  +(mvy>0))>>1) + dmvector[1] + 1;

    }

  }

  else

  {

    /* vector for prediction from field of opposite 'parity' */

    DMV[0][0] = ((mvx+(mvx>0))>>1) + dmvector[0];

    DMV[0][1] = ((mvy+(mvy>0))>>1) + dmvector[1];



    /* correct for vertical field shift */

    if (picture_structure==TOP_FIELD)

      DMV[0][1]--;

    else

      DMV[0][1]++;

  }

}



